ടൈപ്പ്സ്ക്രിപ്റ്റ് ജെനറിക്കുകൾ: ശക്തമായ ആപ്ലിക്കേഷനുകൾക്കായി സങ്കീർണ്ണമായ ഡാറ്റാ ടൈപ്പുകളിൽ പ്രാവീണ്യം നേടാം

ജാവാസ്ക്രിപ്റ്റിൻ്റെ ഒരു സൂപ്പർസെറ്റായ ടൈപ്പ്സ്ക്രിപ്റ്റ്, സ്റ്റാറ്റിക് ടൈപ്പിംഗിലൂടെ കൂടുതൽ ശക്തവും പരിപാലിക്കാൻ എളുപ്പമുള്ളതുമായ കോഡ് എഴുതാൻ ഡെവലപ്പർമാരെ സഹായിക്കുന്നു. ഇതിലെ ഏറ്റവും ശക്തമായ സവിശേഷതകളിലൊന്നാണ് ജെനറിക്കുകൾ, ഇത് ടൈപ്പ് സേഫ്റ്റി നിലനിർത്തിക്കൊണ്ട് തന്നെ പലതരം ഡാറ്റാ ടൈപ്പുകളിൽ പ്രവർത്തിക്കാൻ കഴിയുന്ന കോഡ് എഴുതാൻ നിങ്ങളെ അനുവദിക്കുന്നു. ഈ ഗൈഡ് ടൈപ്പ്സ്ക്രിപ്റ്റ് ജെനറിക്കുകളെക്കുറിച്ചുള്ള ഒരു സമഗ്രമായ പര്യവേക്ഷണം നൽകുന്നു, ആഗോള സോഫ്റ്റ്‌വെയർ വികസനത്തിൻ്റെ പശ്ചാത്തലത്തിൽ സങ്കീർണ്ണമായ ഡാറ്റാ ടൈപ്പുകളിലുള്ള അവയുടെ പ്രയോഗത്തിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്നു.

എന്താണ് ജെനറിക്കുകൾ?

വിവിധതരം ടൈപ്പുകളിൽ പ്രവർത്തിക്കാൻ കഴിയുന്ന പുനരുപയോഗിക്കാവുന്ന കോഡ് എഴുതാനുള്ള ഒരു മാർഗ്ഗമാണ് ജെനറിക്കുകൾ. നിങ്ങൾ പിന്തുണയ്ക്കാൻ ആഗ്രഹിക്കുന്ന ഓരോ ടൈപ്പിനും പ്രത്യേക ഫംഗ്ഷനുകളോ ക്ലാസുകളോ എഴുതുന്നതിനു പകരം, ടൈപ്പ് പാരാമീറ്ററുകൾ ഉപയോഗിക്കുന്ന ഒരൊറ്റ ഫംഗ്ഷനോ ക്ലാസോ എഴുതാൻ കഴിയും. ഈ ടൈപ്പ് പാരാമീറ്ററുകൾ, ഫംഗ്ഷനോ ക്ലാസോ വിളിക്കുകയോ അല്ലെങ്കിൽ ഇൻസ്റ്റാൻഷ്യേറ്റ് ചെയ്യുകയോ ചെയ്യുമ്പോൾ ഉപയോഗിക്കുന്ന യഥാർത്ഥ ടൈപ്പുകൾക്കുള്ള പ്ലെയ്‌സ്‌ഹോൾഡറുകളാണ്. ഡാറ്റാ ഘടനയ്ക്കുള്ളിലെ ഡാറ്റയുടെ തരം വ്യത്യാസപ്പെടാൻ സാധ്യതയുള്ള സങ്കീർണ്ണമായ ഡാറ്റാ സ്ട്രക്ച്ചറുകൾ കൈകാര്യം ചെയ്യുമ്പോൾ ഇത് വളരെ ഉപയോഗപ്രദമാണ്.

ജെനറിക്കുകൾ ഉപയോഗിക്കുന്നതിൻ്റെ പ്രയോജനങ്ങൾ

• കോഡിന്റെ പുനരുപയോഗം: കോഡ് ഒരിക്കൽ എഴുതി വിവിധ തരം ടൈപ്പുകൾക്കൊപ്പം ഉപയോഗിക്കുക. ഇത് കോഡിന്റെ ആവർത്തനം കുറയ്ക്കുകയും നിങ്ങളുടെ കോഡ്ബേസ് കൂടുതൽ പരിപാലിക്കാൻ എളുപ്പമുള്ളതാക്കുകയും ചെയ്യുന്നു.
• ടൈപ്പ് സേഫ്റ്റി: കംപൈൽ ചെയ്യുന്ന സമയത്ത് ടൈപ്പ് സേഫ്റ്റി നടപ്പിലാക്കാൻ ജെനറിക്കുകൾ ടൈപ്പ്സ്ക്രിപ്റ്റ് കംപൈലറിനെ അനുവദിക്കുന്നു. ടൈപ്പ് പൊരുത്തക്കേടുകൾ മൂലമുണ്ടാകുന്ന റൺടൈം പിശകുകൾ തടയാൻ ഇത് സഹായിക്കുന്നു.
• മെച്ചപ്പെട്ട വായനാക്ഷമത: നിങ്ങളുടെ ഫംഗ്ഷനുകളും ക്ലാസുകളും ഏത് ടൈപ്പുകളുമായി പ്രവർത്തിക്കാനാണ് രൂപകൽപ്പന ചെയ്തിരിക്കുന്നതെന്ന് വ്യക്തമാക്കുന്നതിലൂടെ ജെനറിക്കുകൾ നിങ്ങളുടെ കോഡിനെ കൂടുതൽ വായനാക്ഷമമാക്കുന്നു.
• മെച്ചപ്പെട്ട പ്രകടനം: ചില സന്ദർഭങ്ങളിൽ, ഉപയോഗിക്കുന്ന ടൈപ്പുകളെ അടിസ്ഥാനമാക്കി കംപൈലറിന് കോഡ് ഒപ്റ്റിമൈസ് ചെയ്യാൻ കഴിയുന്നതിനാൽ, ജെനറിക്കുകൾ മികച്ച പ്രകടനത്തിലേക്ക് നയിച്ചേക്കാം.

ജെനറിക്കുകളുടെ അടിസ്ഥാന സിന്റാക്സ്

ജെനറിക്കുകളുടെ അടിസ്ഥാന സിന്റാക്സിൽ ടൈപ്പ് പാരാമീറ്ററുകൾ പ്രഖ്യാപിക്കാൻ ആംഗിൾ ബ്രാക്കറ്റുകൾ (< >) ഉപയോഗിക്കുന്നു. ഈ ടൈപ്പ് പാരാമീറ്ററുകൾക്ക് സാധാരണയായി T, K, V എന്നിങ്ങനെയാണ് പേര് നൽകാറുള്ളത്, എന്നാൽ നിങ്ങൾക്ക് സാധുവായ ഏത് ഐഡന്റിഫയറും ഉപയോഗിക്കാം. ഒരു ജെനറിക് ഫംഗ്ഷൻ്റെ ലളിതമായ ഉദാഹരണം താഴെ നൽകുന്നു:

function identity<T>(arg: T): T {
  return arg;
}

let myString: string = identity<string>("hello");
let myNumber: number = identity<number>(123);
let myBoolean: boolean = identity<boolean>(true);

console.log(myString); // Output: hello
console.log(myNumber); // Output: 123
console.log(myBoolean); // Output: true

ഈ ഉദാഹരണത്തിൽ, <T> എന്നത് T എന്ന് പേരുള്ള ഒരു ടൈപ്പ് പാരാമീറ്ററിനെ പ്രഖ്യാപിക്കുന്നു. identity എന്ന ഫംഗ്ഷൻ T ടൈപ്പിലുള്ള ഒരു ആർഗ്യുമെന്റ് എടുക്കുകയും T ടൈപ്പിലുള്ള ഒരു മൂല്യം തിരികെ നൽകുകയും ചെയ്യുന്നു. ഫംഗ്ഷൻ വിളിക്കുമ്പോൾ, നിങ്ങൾക്ക് ടൈപ്പ് പാരാമീറ്റർ വ്യക്തമായി നൽകാം (ഉദാഹരണത്തിന്, identity<string>), അല്ലെങ്കിൽ ആർഗ്യുമെൻ്റ് ടൈപ്പിനെ അടിസ്ഥാനമാക്കി ടൈപ്പ്സ്ക്രിപ്റ്റിനെ അത് ഊഹിച്ചെടുക്കാൻ അനുവദിക്കാം.

സങ്കീർണ്ണമായ ഡാറ്റാ ടൈപ്പുകളുമായി പ്രവർത്തിക്കുമ്പോൾ

അറേകൾ, ഒബ്‌ജക്റ്റുകൾ, ഇൻ്റർഫേസുകൾ പോലുള്ള സങ്കീർണ്ണമായ ഡാറ്റാ ടൈപ്പുകൾ കൈകാര്യം ചെയ്യുമ്പോൾ ജെനറിക്കുകൾക്ക് പ്രത്യേക മൂല്യമുണ്ട്. സാധാരണമായ ചില സാഹചര്യങ്ങൾ നമുക്ക് പരിശോധിക്കാം:

ജെനറിക് അറേകൾ

വിവിധ തരം അറേകളിൽ പ്രവർത്തിക്കുന്ന ഫംഗ്ഷനുകളോ ക്ലാസുകളോ ഉണ്ടാക്കാൻ നിങ്ങൾക്ക് ജെനറിക്കുകൾ ഉപയോഗിക്കാം:

function arrayToString<T>(arr: T[]): string {
  return arr.join(", ");
}

let numberArray: number[] = [1, 2, 3, 4, 5];
let stringArray: string[] = ["apple", "banana", "cherry"];

console.log(arrayToString(numberArray)); // Output: 1, 2, 3, 4, 5
console.log(arrayToString(stringArray)); // Output: apple, banana, cherry

ഇവിടെ, arrayToString എന്ന ഫംഗ്ഷൻ T[] ടൈപ്പിലുള്ള ഒരു അറേ എടുക്കുകയും ആ അറേയുടെ സ്ട്രിംഗ് രൂപം നൽകുകയും ചെയ്യുന്നു. ഈ ഫംഗ്ഷൻ ഏത് തരം അറേകളിലും പ്രവർത്തിക്കും, ഇത് വളരെ പുനരുപയോഗിക്കാവുന്നതാക്കുന്നു.

ജെനറിക് ഒബ്ജക്റ്റുകൾ

വിവിധ രൂപങ്ങളിലുള്ള ഒബ്ജക്റ്റുകളിൽ പ്രവർത്തിക്കുന്ന ഫംഗ്ഷനുകളോ ക്ലാസുകളോ നിർവചിക്കാനും ജെനറിക്കുകൾ ഉപയോഗിക്കാം:

interface Person {
  name: string;
  age: number;
  country: string; // Added country for global context
}

interface Product {
  id: number;
  name: string;
  price: number;
  currency: string; // Added currency for global context
}

function displayInfo<T extends { name: string }>(item: T): void {
  console.log(`Name: ${item.name}`);
}

let person: Person = { name: "Alice", age: 30, country: "USA" };
let product: Product = { id: 1, name: "Laptop", price: 1200, currency: "USD" };

displayInfo(person); // Output: Name: Alice
displayInfo(product); // Output: Name: Laptop

ഈ ഉദാഹരണത്തിൽ, displayInfo എന്ന ഫംഗ്ഷൻ T ടൈപ്പിലുള്ള ഒരു ഒബ്ജക്റ്റ് എടുക്കുന്നു, അതിൽ നിർബന്ധമായും സ്ട്രിംഗ് ടൈപ്പിലുള്ള ഒരു name പ്രോപ്പർട്ടി ഉണ്ടായിരിക്കണം. extends { name: string } എന്നത് ഒരു കൺസ്ട്രെയിൻ്റ് ആണ്, ഇത് T എന്ന ടൈപ്പ് പാരാമീറ്ററിന് വേണ്ട ഏറ്റവും കുറഞ്ഞ ആവശ്യകതകൾ വ്യക്തമാക്കുന്നു. ഇത് ഫംഗ്ഷന് name പ്രോപ്പർട്ടി സുരക്ഷിതമായി ഉപയോഗിക്കാൻ കഴിയുമെന്ന് ഉറപ്പാക്കുന്നു.

ജെനറിക്കുകളുടെ നൂതന ഉപയോഗം

കൂടുതൽ ഫ്ലെക്സിബിളും ശക്തവുമായ കോഡ് ഉണ്ടാക്കാൻ സഹായിക്കുന്ന നൂതന സവിശേഷതകൾ ടൈപ്പ്സ്ക്രിപ്റ്റ് ജെനറിക്കുകൾ നൽകുന്നു. അവയിൽ ചിലത് നമുക്ക് പരിശോധിക്കാം:

ഒന്നിലധികം ടൈപ്പ് പാരാമീറ്ററുകൾ

നിങ്ങൾക്ക് ഒന്നിലധികം ടൈപ്പ് പാരാമീറ്ററുകളുള്ള ഫംഗ്ഷനുകളോ ക്ലാസുകളോ നിർവചിക്കാൻ കഴിയും:

function merge<T, U>(obj1: T, obj2: U): T & U {
  return { ...obj1, ...obj2 };
}

interface Name {
  firstName: string;
}

interface Age {
  age: number;
}

const person: Name = { firstName: "Bob" };
const details: Age = { age: 42 };

const merged = merge(person, details);
console.log(merged.firstName); // Output: Bob
console.log(merged.age); // Output: 42

merge എന്ന ഫംഗ്ഷൻ T, U എന്നീ ടൈപ്പുകളിലുള്ള രണ്ട് ഒബ്ജക്റ്റുകൾ എടുക്കുകയും, രണ്ടിലെയും പ്രോപ്പർട്ടികൾ ഉൾക്കൊള്ളുന്ന ഒരു പുതിയ ഒബ്ജക്റ്റ് നൽകുകയും ചെയ്യുന്നു. വിവിധ ഉറവിടങ്ങളിൽ നിന്നുള്ള ഡാറ്റ സംയോജിപ്പിക്കാനുള്ള ശക്തമായ മാർഗ്ഗമാണിത്.

ജെനറിക് കൺസ്ട്രെയിൻ്റ്സ്

നേരത്തെ കാണിച്ചതുപോലെ, ഒരു ജെനറിക് ടൈപ്പ് പാരാമീറ്ററിനൊപ്പം ഉപയോഗിക്കാവുന്ന ടൈപ്പുകളെ നിയന്ത്രിക്കാൻ കൺസ്ട്രെയിൻ്റുകൾ നിങ്ങളെ അനുവദിക്കുന്നു. ഇത് നിങ്ങളുടെ ജെനറിക് കോഡിന് നിർദ്ദിഷ്ട ടൈപ്പുകളിൽ സുരക്ഷിതമായി പ്രവർത്തിക്കാൻ കഴിയുമെന്ന് ഉറപ്പാക്കുന്നു.

interface Lengthwise {
  length: number;
}

function loggingIdentity<T extends Lengthwise>(arg: T): T {
  console.log(arg.length);
  return arg;
}

loggingIdentity([1, 2, 3]); // Output: 3
loggingIdentity("hello"); // Output: 5
// loggingIdentity(123); // Error: Argument of type 'number' is not assignable to parameter of type 'Lengthwise'.

loggingIdentity എന്ന ഫംഗ്ഷൻ T ടൈപ്പിലുള്ള ഒരു ആർഗ്യുമെന്റ് എടുക്കുന്നു, അതിന് നമ്പർ ടൈപ്പിലുള്ള ഒരു length പ്രോപ്പർട്ടി ഉണ്ടായിരിക്കണം. ഇത് ഫംഗ്ഷന് length പ്രോപ്പർട്ടി സുരക്ഷിതമായി ഉപയോഗിക്കാൻ കഴിയുമെന്ന് ഉറപ്പാക്കുന്നു.

ജെനറിക് ക്ലാസുകൾ

ജെനറിക്കുകൾ ക്ലാസുകളോടൊപ്പവും ഉപയോഗിക്കാം:

class DataStorage<T> {
  private data: T[] = [];

  addItem(item: T) {
    this.data.push(item);
  }

  removeItem(item: T) {
    this.data = this.data.filter(d => d !== item);
  }

  getItems(): T[] {
    return [...this.data];
  }
}

const textStorage = new DataStorage<string>();
textStorage.addItem("apple");
textStorage.addItem("banana");
textStorage.removeItem("apple");
console.log(textStorage.getItems()); // Output: [ 'banana' ]

const numberStorage = new DataStorage<number>();
numberStorage.addItem(1);
numberStorage.addItem(2);
numberStorage.removeItem(1);
console.log(numberStorage.getItems()); // Output: [ 2 ]

DataStorage എന്ന ക്ലാസിന് T എന്ന ഏത് ടൈപ്പിലുള്ള ഡാറ്റയും സംഭരിക്കാൻ കഴിയും. ഇത് ടൈപ്പ്-സേഫ് ആയ, പുനരുപയോഗിക്കാവുന്ന ഡാറ്റാ ഘടനകൾ ഉണ്ടാക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു.

ജെനറിക് ഇൻ്റർഫേസുകൾ

വിവിധതരം ടൈപ്പുകളിൽ പ്രവർത്തിക്കാൻ കഴിയുന്ന കോൺട്രാക്ടുകൾ നിർവചിക്കാൻ ജെനറിക് ഇൻ്റർഫേസുകൾ ഉപയോഗപ്രദമാണ്. ഉദാഹരണത്തിന്:

interface Result<T, E> {
  success: boolean;
  data?: T;
  error?: E;
}

interface User {
  id: number;
  username: string;
  email: string;
}

interface ErrorMessage {
  code: number;
  message: string;
}

function fetchUser(id: number): Result<User, ErrorMessage> {
  if (id === 1) {
    return { success: true, data: { id: 1, username: "john.doe", email: "john.doe@example.com" } };
  } else {
    return { success: false, error: { code: 404, message: "User not found" } };
  }
}

const userResult = fetchUser(1);
if (userResult.success) {
  console.log(userResult.data.username);
} else {
  console.log(userResult.error.message);
}

Result എന്ന ഇൻ്റർഫേസ് ഒരു ഓപ്പറേഷൻ്റെ ഫലം കാണിക്കാനുള്ള ഒരു ജെനറിക് ഘടന നിർവചിക്കുന്നു. ഇതിൽ T ടൈപ്പിലുള്ള ഡാറ്റയോ അല്ലെങ്കിൽ E ടൈപ്പിലുള്ള ഒരു എററോ ഉണ്ടാകാം. അസിൻക്രണസ് പ്രവർത്തനങ്ങളോ പരാജയപ്പെടാൻ സാധ്യതയുള്ള പ്രവർത്തനങ്ങളോ കൈകാര്യം ചെയ്യുന്നതിനുള്ള ഒരു സാധാരണ രീതിയാണിത്.

യൂട്ടിലിറ്റി ടൈപ്പുകളും ജെനറിക്കുകളും

ടൈപ്പ്സ്ക്രിപ്റ്റ്, ജെനറിക്കുകളുമായി നന്നായി പ്രവർത്തിക്കുന്ന നിരവധി ബിൽറ്റ്-ഇൻ യൂട്ടിലിറ്റി ടൈപ്പുകൾ നൽകുന്നു. ടൈപ്പുകളെ ശക്തമായ രീതിയിൽ മാറ്റാനും കൈകാര്യം ചെയ്യാനും ഈ യൂട്ടിലിറ്റി ടൈപ്പുകൾ നിങ്ങളെ സഹായിക്കും.

Partial<T>

Partial<T> എന്നത് T എന്ന ടൈപ്പിൻ്റെ എല്ലാ പ്രോപ്പർട്ടികളെയും ഓപ്ഷണൽ ആക്കുന്നു:

interface Person {
  name: string;
  age: number;
}

type PartialPerson = Partial<Person>;

const partialPerson: PartialPerson = { name: "Alice" }; // Valid

Readonly<T>

Readonly<T> എന്നത് T എന്ന ടൈപ്പിൻ്റെ എല്ലാ പ്രോപ്പർട്ടികളെയും റീഡ്-ഒൺലി ആക്കുന്നു:

interface Person {
  name: string;
  age: number;
}

type ReadonlyPerson = Readonly<Person>;

const readonlyPerson: ReadonlyPerson = { name: "Bob", age: 42 };
// readonlyPerson.age = 43; // Error: Cannot assign to 'age' because it is a read-only property.

Pick<T, K>

Pick<T, K> എന്നത് T എന്ന ടൈപ്പിൽ നിന്ന് K എന്ന ഒരു കൂട്ടം പ്രോപ്പർട്ടികളെ തിരഞ്ഞെടുക്കുന്നു:

interface Person {
  name: string;
  age: number;
  email: string;
}

type NameAndAge = Pick<Person, "name" | "age">;

const nameAndAge: NameAndAge = { name: "Charlie", age: 28 };

Omit<T, K>

Omit<T, K> എന്നത് T എന്ന ടൈപ്പിൽ നിന്ന് K എന്ന ഒരു കൂട്ടം പ്രോപ്പർട്ടികളെ നീക്കംചെയ്യുന്നു:

interface Person {
  name: string;
  age: number;
  email: string;
}

type PersonWithoutEmail = Omit<Person, "email">;

const personWithoutEmail: PersonWithoutEmail = { name: "David", age: 35 };

Record<K, T>

Record<K, T> എന്നത് K എന്ന കീകളും T എന്ന ടൈപ്പിലുള്ള മൂല്യങ്ങളുമുള്ള ഒരു ടൈപ്പ് ഉണ്ടാക്കുന്നു:

type CountryCodes = "US" | "CA" | "UK" | "DE" | "FR" | "JP" | "CN" | "IN" | "BR" | "AU"; // Expanded list for global context
type Currency = "USD" | "CAD" | "GBP" | "EUR" | "JPY" | "CNY" | "INR" | "BRL" | "AUD"; // Expanded list for global context

type CurrencyMap = Record<CountryCodes, Currency>;

const currencyMap: CurrencyMap = {
  "US": "USD",
  "CA": "CAD",
  "UK": "GBP",
  "DE": "EUR",
  "FR": "EUR",
  "JP": "JPY",
  "CN": "CNY",
  "IN": "INR",
  "BR": "BRL",
  "AU": "AUD",
};

മാപ്പ്ഡ് ടൈപ്പുകൾ

നിലവിലുള്ള ടൈപ്പുകളുടെ പ്രോപ്പർട്ടികളിലൂടെ കടന്നുപോയി അവയെ രൂപാന്തരപ്പെടുത്താൻ മാപ്പ്ഡ് ടൈപ്പുകൾ നിങ്ങളെ അനുവദിക്കുന്നു. നിലവിലുള്ള ടൈപ്പുകളെ അടിസ്ഥാനമാക്കി പുതിയ ടൈപ്പുകൾ ഉണ്ടാക്കാനുള്ള ശക്തമായ മാർഗ്ഗമാണിത്. ഉദാഹരണത്തിന്, മറ്റൊരു ടൈപ്പിൻ്റെ എല്ലാ പ്രോപ്പർട്ടികളെയും റീഡ്-ഒൺലി ആക്കുന്ന ഒരു ടൈപ്പ് നിങ്ങൾക്ക് ഉണ്ടാക്കാം:

interface Person {
  name: string;
  age: number;
}

type ReadonlyPerson = {
  readonly [K in keyof Person]: Person[K];
};

const readonlyPerson: ReadonlyPerson = { name: "Eve", age: 25 };
// readonlyPerson.age = 26; // Error: Cannot assign to 'age' because it is a read-only property.

ഈ ഉദാഹരണത്തിൽ, [K in keyof Person] എന്നത് Person ഇൻ്റർഫേസിൻ്റെ എല്ലാ കീകളിലൂടെയും കടന്നുപോകുന്നു, കൂടാതെ Person[K] ഓരോ പ്രോപ്പർട്ടിയുടെയും ടൈപ്പ് എടുക്കുന്നു. readonly എന്ന കീവേഡ് ഓരോ പ്രോപ്പർട്ടിയെയും റീഡ്-ഒൺലി ആക്കുന്നു.

കണ്ടീഷണൽ ടൈപ്പുകൾ

വ്യവസ്ഥകളെ അടിസ്ഥാനമാക്കി ടൈപ്പുകൾ നിർവചിക്കാൻ കണ്ടീഷണൽ ടൈപ്പുകൾ നിങ്ങളെ അനുവദിക്കുന്നു. വിവിധ സാഹചര്യങ്ങളുമായി പൊരുത്തപ്പെടുന്ന ടൈപ്പുകൾ ഉണ്ടാക്കാനുള്ള ശക്തമായ മാർഗ്ഗമാണിത്.

type NonNullable<T> = T extends null | undefined ? never : T;

type MaybeString = string | null | undefined;
type StringType = NonNullable<MaybeString>; // string

function getValue<T>(value: T): NonNullable<T> {
  if (value == null) { // Handles both null and undefined
    throw new Error("Value cannot be null or undefined");
  }
  return value as NonNullable<T>;
}

try {
  const validValue = getValue("hello");
  console.log(validValue.toUpperCase()); // Output: HELLO

  const invalidValue = getValue(null); // This will throw an error
  console.log(invalidValue); // This line will not be reached
} catch (error: any) {
  console.error(error.message); // Output: Value cannot be null or undefined
}

ഈ ഉദാഹരണത്തിൽ, NonNullable<T> എന്ന ടൈപ്പ് T എന്നത് null അല്ലെങ്കിൽ undefined ആണോ എന്ന് പരിശോധിക്കുന്നു. അങ്ങനെയാണെങ്കിൽ, അത് never എന്ന് നൽകുന്നു, അതിനർത്ഥം ആ ടൈപ്പ് അനുവദനീയമല്ല എന്നാണ്. അല്ലെങ്കിൽ, അത് T എന്ന് നൽകുന്നു. ഇത് നിങ്ങൾക്ക് നൾ ആകാൻ സാധ്യതയില്ലാത്ത ടൈപ്പുകൾ ഉണ്ടാക്കാൻ അനുവദിക്കുന്നു.

ജെനറിക്കുകൾ ഉപയോഗിക്കുന്നതിനുള്ള മികച്ച രീതികൾ

ജെനറിക്കുകൾ ഉപയോഗിക്കുമ്പോൾ ഓർത്തിരിക്കേണ്ട ചില മികച്ച രീതികൾ താഴെക്കൊടുക്കുന്നു:

• വിവരണാത്മകമായ ടൈപ്പ് പാരാമീറ്റർ പേരുകൾ ഉപയോഗിക്കുക: ടൈപ്പ് പാരാമീറ്ററിൻ്റെ ഉദ്ദേശ്യം വ്യക്തമാക്കുന്ന പേരുകൾ തിരഞ്ഞെടുക്കുക.
• ഒരു ജെനറിക് ടൈപ്പ് പാരാമീറ്ററിനൊപ്പം ഉപയോഗിക്കാവുന്ന ടൈപ്പുകളെ പരിമിതപ്പെടുത്താൻ കൺസ്ട്രെയിൻ്റുകൾ ഉപയോഗിക്കുക: ഇത് നിങ്ങളുടെ ജെനറിക് കോഡിന് നിർദ്ദിഷ്ട ടൈപ്പുകളിൽ സുരക്ഷിതമായി പ്രവർത്തിക്കാൻ കഴിയുമെന്ന് ഉറപ്പാക്കുന്നു.
• നിങ്ങളുടെ ജെനറിക് കോഡ് ലളിതവും ശ്രദ്ധാകേന്ദ്രീകൃതവുമാക്കി നിലനിർത്തുക: വളരെയധികം ടൈപ്പ് പാരാമീറ്ററുകളോ സങ്കീർണ്ണമായ കൺസ്ട്രെയിൻ്റുകളോ ഉപയോഗിച്ച് നിങ്ങളുടെ ജെനറിക് കോഡ് സങ്കീർണ്ണമാക്കുന്നത് ഒഴിവാക്കുക.
• നിങ്ങളുടെ ജെനറിക് കോഡ് വിശദമായി ഡോക്യുമെൻ്റ് ചെയ്യുക: ടൈപ്പ് പാരാമീറ്ററുകളുടെ ഉദ്ദേശ്യവും ഉപയോഗിക്കുന്ന കൺസ്ട്രെയിൻ്റുകളും വിശദീകരിക്കുക.
• കോഡിൻ്റെ പുനരുപയോഗവും ടൈപ്പ് സേഫ്റ്റിയും തമ്മിലുള്ള ഗുണദോഷങ്ങൾ പരിഗണിക്കുക: ജെനറിക്കുകൾക്ക് കോഡിൻ്റെ പുനരുപയോഗം മെച്ചപ്പെടുത്താൻ കഴിയുമെങ്കിലും, അവ നിങ്ങളുടെ കോഡിനെ കൂടുതൽ സങ്കീർണ്ണമാക്കിയേക്കാം. ജെനറിക്കുകൾ ഉപയോഗിക്കുന്നതിന് മുമ്പ് ഗുണങ്ങളും ദോഷങ്ങളും വിലയിരുത്തുക.
• ലോക്കലൈസേഷനും ഗ്ലോബലൈസേഷനും (l10n and g11n) പരിഗണിക്കുക: വിവിധ പ്രദേശങ്ങളിലെ ഉപയോക്താക്കൾക്ക് പ്രദർശിപ്പിക്കേണ്ട ഡാറ്റ കൈകാര്യം ചെയ്യുമ്പോൾ, നിങ്ങളുടെ ജെനറിക്കുകൾ ഉചിതമായ ഫോർമാറ്റിംഗും സാംസ്കാരിക കീഴ്വഴക്കങ്ങളും പിന്തുണയ്ക്കുന്നുവെന്ന് ഉറപ്പാക്കുക. ഉദാഹരണത്തിന്, നമ്പറും തീയതിയും ഫോർമാറ്റ് ചെയ്യുന്നത് ഓരോ രാജ്യത്തും വളരെ വ്യത്യാസപ്പെട്ടിരിക്കും.

ഒരു ആഗോള പശ്ചാത്തലത്തിലെ ഉദാഹരണങ്ങൾ

ഒരു ആഗോള പശ്ചാത്തലത്തിൽ ജെനറിക്കുകൾ എങ്ങനെ ഉപയോഗിക്കാം എന്നതിൻ്റെ ചില ഉദാഹരണങ്ങൾ പരിഗണിക്കാം:

കറൻസി പരിവർത്തനം

interface ConversionRate {
  rate: number;
  fromCurrency: string;
  toCurrency: string;
}

function convertCurrency<T extends ConversionRate>(amount: number, rate: T): number {
  return amount * rate.rate;
}

const usdToEurRate: ConversionRate = { rate: 0.85, fromCurrency: "USD", toCurrency: "EUR" };
const amountInUSD = 100;
const amountInEUR = convertCurrency(amountInUSD, usdToEurRate);
console.log(`${amountInUSD} USD is equal to ${amountInEUR} EUR`); // Output: 100 USD is equal to 85 EUR

തീയതി ഫോർമാറ്റിംഗ്

interface DateFormatOptions {
  locale: string;
  options: Intl.DateTimeFormatOptions;
}

function formatDate<T extends DateFormatOptions>(date: Date, format: T): string {
  return date.toLocaleDateString(format.locale, format.options);
}

const currentDate = new Date();

const usDateFormat: DateFormatOptions = { locale: "en-US", options: { year: 'numeric', month: 'long', day: 'numeric' } };
const germanDateFormat: DateFormatOptions = { locale: "de-DE", options: { year: 'numeric', month: 'long', day: 'numeric' } };
const japaneseDateFormat: DateFormatOptions = { locale: "ja-JP", options: { year: 'numeric', month: 'long', day: 'numeric' } };

console.log("US Date: " + formatDate(currentDate, usDateFormat));
console.log("German Date: " + formatDate(currentDate, germanDateFormat));
console.log("Japanese Date: " + formatDate(currentDate, japaneseDateFormat));

വിവർത്തന സേവനം

interface Translation {
  [key: string]: string; // Allows for dynamic language keys
}

interface LanguageData<T extends Translation> {
  languageCode: string;
  translations: T;
}

const englishTranslations: Translation = {
  "hello": "Hello",
  "goodbye": "Goodbye",
  "welcome": "Welcome to our website!"
};

const spanishTranslations: Translation = {
  "hello": "Hola",
  "goodbye": "Adiós",
  "welcome": "¡Bienvenido a nuestro sitio web!"
};

const frenchTranslations: Translation = {
  "hello": "Bonjour",
  "goodbye": "Au revoir",
  "welcome": "Bienvenue sur notre site web !"
};


const languageData: LanguageData<typeof englishTranslations>[] = [
  {languageCode: "en", translations: englishTranslations },
  {languageCode: "es", translations: spanishTranslations },
  {languageCode: "fr", translations: frenchTranslations}
];

function translate<T extends Translation>(key: string, languageCode: string, languageData: LanguageData<T>[]): string {
  const lang = languageData.find(lang => lang.languageCode === languageCode);
  if (!lang) {
    return `Translation for ${key} in ${languageCode} not found.`;
  }
  return lang.translations[key] || `Translation for ${key} not found.`;
}

console.log(translate("hello", "en", languageData)); // Output: Hello
console.log(translate("hello", "es", languageData)); // Output: Hola
console.log(translate("welcome", "fr", languageData)); // Output: Bienvenue sur notre site web !
console.log(translate("missingKey", "de", languageData)); // Output: Translation for missingKey in de not found.

ഉപസംഹാരം

പുനരുപയോഗിക്കാവുന്നതും, ടൈപ്പ്-സേഫ് ആയതും, സങ്കീർണ്ണമായ ഡാറ്റാ ടൈപ്പുകളിൽ പ്രവർത്തിക്കാൻ കഴിയുന്നതുമായ കോഡ് എഴുതുന്നതിനുള്ള ശക്തമായ ഒരു ഉപകരണമാണ് ടൈപ്പ്സ്ക്രിപ്റ്റ് ജെനറിക്കുകൾ. ജെനറിക്കുകളുടെ അടിസ്ഥാന സിന്റാക്സ്, നൂതന സവിശേഷതകൾ, മികച്ച രീതികൾ എന്നിവ മനസ്സിലാക്കുന്നതിലൂടെ, നിങ്ങളുടെ ടൈപ്പ്സ്ക്രിപ്റ്റ് ആപ്ലിക്കേഷനുകളുടെ ഗുണനിലവാരവും പരിപാലനക്ഷമതയും ഗണ്യമായി മെച്ചപ്പെടുത്താൻ നിങ്ങൾക്ക് കഴിയും. ഒരു ആഗോള പ്രേക്ഷകർക്കായി ആപ്ലിക്കേഷനുകൾ വികസിപ്പിക്കുമ്പോൾ, വൈവിധ്യമാർന്ന ഡാറ്റാ ഫോർമാറ്റുകളും സാംസ്കാരിക കീഴ്വഴക്കങ്ങളും കൈകാര്യം ചെയ്യാൻ ജെനറിക്കുകൾക്ക് നിങ്ങളെ സഹായിക്കാൻ കഴിയും, ഇത് എല്ലാവർക്കും തടസ്സമില്ലാത്ത ഉപയോക്തൃ അനുഭവം ഉറപ്പാക്കുന്നു.